﻿/***************************************************************************
 * 文件名：常量类生成类
 * 功能：
 * 说明：
 * -------------------------------------------------------------------------
 * 创建时间：2025/7/10 09:19:14
 * 创建人：葛浩
 * 邮箱： 2094733071@qq.com
 * =========================================================================
 *
 * 修改人：   
 * 修改时间：   
 * 修改说明：   
 ***************************************************************************/
using System;
using System.Linq;
using System.Text.RegularExpressions;

namespace ConstClassGenerator
{
    public class ConstGenerator: IConstClassGenerator
	{
        /// <summary>
        /// 默认常量类名称
        /// </summary>
        private const string c_DefaultConstClassName = "XXXConst";

		/// <summary>
		///  是否匹配常量类生成的字符串格式
		/// </summary>
		/// <param name="inputValue"></param>
		/// <returns></returns>
		public static bool IsMatch(string inputValue)
        {
            if (string.IsNullOrWhiteSpace(inputValue))
            {
                return false;
            }

            //样例
            // [常量类说明]（1:张三 2：李四, 3:王五）
            if (Regex.IsMatch(inputValue, @"^(.*?)[(（]([^(（]*?)[）)]"))
            {
                inputValue = Regex.Match(inputValue, @"^(.*?)[(（]([^(（]*?)[）)]$")
                    .Groups[2].Value;
            }

            // 1:张三 2：李四, 3:王五
            return Regex.IsMatch(inputValue, @"([^:：\s（）(),，]+)(?:\s*)[:：](?:\s*)([^:：\s（）(),，]+)(?:[,，\s]|$)");
        }

       /// <summary>
       /// 生成常量类
       /// </summary>
       /// <param name="inputValue"></param>
       /// <param name="constClassName"></param>
       /// <returns></returns>
       /// <exception cref="ConstClassGeneratorException"></exception>
        public string ConstClassGeneratorExecute(string inputValue,string constClassName)
        {
            if (string.IsNullOrWhiteSpace(inputValue))
            {
                throw new ConstClassGeneratorException(1, "输入字符串为空");
            }

            //若常量类名称为空，则使用默认名称
            if (string.IsNullOrEmpty(constClassName))
            {
                constClassName = c_DefaultConstClassName;
			}

            var classSummary = string.Empty;
            // [常量类说明]（1:张三 2：李四, 3:王五）
            if (Regex.IsMatch(inputValue, @"^(.*?)[(（]([^(（]*?)[）)]"))
            {
                var matcheGroups = Regex.Match(inputValue, @"^(.*?)[(（]([^(（]*?)[）)]$")
                    .Groups;
                classSummary = matcheGroups[1].Value;
                inputValue = matcheGroups[2].Value;
            }

            if (Regex.IsMatch(inputValue, @"([^:：\s（）(),，]+)(?:\s*)[:：](?:\s*)([^:：\s（）(),，]+)(?:[,，\s]|$)"))
            {
                var matches = Regex.Matches(inputValue, @"([^:：\s（）(),，]+)(?:\s*)[:：](?:\s*)([^:：\s（）(),，]+)(?:[,，\s]|$)")
                    .OfType<Match>()
                    .Select(p => new
                    {
                        Name = GetValidConstName(p.Groups[1].Value),
						Value = p.Groups[1].Value,
                        Summary = p.Groups[2].Value,
                    }).ToList();
                // 常量字段
                var constFieldsStr = string.Join(Environment.NewLine, matches.Select(p => string.Format(@"        /// <summary>
        /// {0}
        /// </summary>
        public const string {1} = ""{2}"";", p.Summary, Regex.IsMatch(p.Value, @"^[^a-zA-Z_].*") ? ($"C{p.Value}") : p.Name, p.Value)));
                // 键值对
                var keyValuesStr = string.Join(Environment.NewLine, matches.Select(p => string.Format(@"            {{{0}, ""{1}""}},", Regex.IsMatch(p.Value, @"^[^a-zA-Z_].*") ? ($"C{p.Value}") : p.Name, p.Summary)));

                // 拼接
                return string.Format(@"    /// <summary>
    /// {0}
    /// </summary>
    public class {3}
    {{
        #region Const Fields

{1}

        #endregion

        private static readonly Dictionary<string, string> _names = new Dictionary<string, string>()
        {{
{2}
        }};
        
        #region Methods

        /// <summary>
        /// 获取名称
        /// </summary>
        /// <returns></returns>
        public static string GetName(string key)
        {{
            return key == null || !_names.ContainsKey(key) ? string.Empty : _names[key];
        }}

        /// <summary>
        /// 常量列表
        /// </summary>
        /// <returns></returns>
        public static string[] GetAllKeys()
        {{
            return _names.Keys.ToArray();
        }}
        
        /// <summary>
        /// 键值列表
        /// </summary>
        /// <returns></returns>
        public static List<KeyValuePair<string, string>> GetList()
        {{
            return _names.ToList();
        }}

        #endregion
    }}", classSummary, constFieldsStr, keyValuesStr,constClassName);
            }
            throw new ConstClassGeneratorException(2, "与默认正则不匹配！请先复制形如下的字符串\r\n“常量类说明（1:张三 2：李四, 3:王五）”\r\n或“（1:张三 2：李四, 3:王五）”\r\n或“1:张三 2：李四, 3:王五”");
        }

        /// <summary>
        /// 常量名称修改
        /// </summary>
        /// <param name="name"></param>
        /// <returns></returns>
        private static string GetValidConstName(string input)
        {
			if (string.IsNullOrEmpty(input))
            {
				return input;
			}

			// 首字母大写 + 剩余部分保持原样
			return char.ToUpper(input[0]) + input.Substring(1);
		}

	}

    public class ConstClassGeneratorException : Exception
    {
        public int ErrorCode { get; private set; }

        public ConstClassGeneratorException()
            : base()
        {
        }

        public ConstClassGeneratorException(string message)
            : base(message)
        {
        }

        public ConstClassGeneratorException(int errorCode, string message)
            : base(message)
        {
            this.ErrorCode = errorCode;
        }

        public ConstClassGeneratorException(int errorCode, string message, Exception innerException)
            : base(message, innerException)
        {
            this.ErrorCode = errorCode;
        }
    }
}
